home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / program / funnel.zoo / sources / memory.c < prev    next >
C/C++ Source or Header  |  1993-04-11  |  15KB  |  339 lines
  1. /*##############################################################################
  2.  
  3. FUNNNELWEB COPYRIGHT
  4. ====================
  5. FunnelWeb is a literate-programming macro preprocessor.
  6.  
  7. Copyright (C) 1992 Ross N. Williams.
  8.  
  9.    Ross N. Williams
  10.    ross@spam.adelaide.edu.au
  11.    16 Lerwick Avenue, Hazelwood Park 5066, Australia.
  12.  
  13. This program is free software; you can redistribute it and/or modify
  14. it under the terms of Version 2 of the GNU General Public License as
  15. published by the Free Software Foundation.
  16.  
  17. This program is distributed WITHOUT ANY WARRANTY; without even the implied
  18. warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  19. See Version 2 of the GNU General Public License for more details.
  20.  
  21. You should have received a copy of Version 2 of the GNU General Public
  22. License along with this program. If not, you can FTP the license from
  23. prep.ai.mit.edu/pub/gnu/COPYING-2 or write to the Free Software
  24. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  
  26. Section 2a of the license requires that all changes to this file be
  27. recorded prominently in this file. Please record all changes here.
  28.  
  29. Programmers:
  30.    RNW  Ross N. Williams  ross@spam.adelaide.edu.au
  31.  
  32. Changes:
  33.    07-May-1992  RNW  Program prepared for release under GNU GPL V2.
  34.  
  35. ##############################################################################*/
  36.  
  37.  
  38. /******************************************************************************/
  39. /*                                  MEMORY.C                                  */
  40. /******************************************************************************/
  41. /*                                                                            */
  42. /* Implementation Overview                                                    */
  43. /* -----------------------                                                    */
  44. /* One of the tasks of this Memory Management (MM) package is to keep track   */
  45. /* of the memory that it has allocated so that it can all be deallocated      */
  46. /* later, in one go. To do this, the package keeps a linked list whose        */
  47. /* elements describe the blocks allocated. Two linked lists are kept, one for */
  48. /* temporary blocks and one for permanent blocks. Only the list for the       */
  49. /* temporary blocks is used for deallocation. Permanent blocks are arranged   */
  50. /* in a list so that the code for temporary blocks is also applicable.        */
  51. /*                                                                            */
  52. /* In order to avoid many calls to malloc() for small blocks of memory        */
  53. /* (legend has it that some implementations of malloc() are very slow in this */
  54. /* case), the MM package keeps a spare temporary and permanent block of       */
  55. /* length MM_BLOCK from which it allocates small blocks. Small is defined as  */
  56. /* <=MM_BLOCK/16. A separate malloc call is made for "Large" blocks greater   */
  57. /* than MM_BLOCK bytes. "Large" blocks less than MM_BLOCK bytes may or may    */
  58. /* not be allocated from a buffer block, depending on how much space is       */
  59. /* available. See the code for the full details.                              */
  60. /*                                                                            */
  61. /******************************************************************************/
  62.  
  63. #include "style.h"
  64.  
  65. #include "as.h"
  66. #include "machin.h"
  67. #include "memory.h"
  68.  
  69. /******************************************************************************/
  70.  
  71. /* The environ.h file contains a definition for ALIGN_POWER which is the      */
  72. /* exponent of the power of two corresponding to the machine's alignment      */
  73. /* requirements. The following two constants convert that constant to more    */
  74. /* useful forms. These definitions should never need to be changed.           */
  75. #define ALIGN_SIZE (1L<<ALIGN_POWER)
  76. #define ALIGN_MASK (ALIGN_SIZE-1)
  77.  
  78. /* Because standard malloc() can be slow on some systems for large numbers of */
  79. /* calls requesting small blocks of memory, FunnelWeb's memory management     */
  80. /* package MM_* allocates memory in sizeable blocks and then allocates        */
  81. /* smaller blocks from these big blocks without reference to malloc(). The    */
  82. /* following #define tells the MM package how big the sizeable allocated      */
  83. /* blocks should be. The rule is then: if the requested block is greater than */
  84. /* MM_BLOCK/16, allocate it directly using malloc(), otherwise peel off some  */
  85. /* memory from the latest sizeable block allocated.                           */
  86. /* In practice, MM_BLOCK should be chosen to be about 1/10 to 1/20 of the     */
  87. /* memory available to FunnelWeb. The disadvantage of making it big is that   */
  88. /* when memory is tight, MM will be unable to allocate a full block and about */
  89. /* half a block of memory will be unusable. The disadvantage of making it too */
  90. /* small is that the linked lists tracking memory allocations will grow long  */
  91. /* and it will take a long time to free up memory between invocations of      */
  92. /* FunnelWeb proper. The value is not critical. A value of 31K should work    */
  93. /* well on most systems. 31K is chosen instead of 32K just to be on the safe  */
  94. /* side of 16 bits (so who's paranoid?).                                      */
  95. #define MM_BLOCK (31L*1024L)
  96.  
  97. /* This definition provides the definition of the size of a "big" block; that */
  98. /* is, one that should possibly be treated differently from the others.       */
  99. /* The rule we use is that a big block is 1/16 of the standard block size.    */
  100. /* This results in a maximum memory wastage of 1/16 or about 7%.              */
  101. #define MM_BIG (MM_BLOCK >> 4)
  102.  
  103. /* Magic numbers help us to detect corruptions. */
  104. #define MAGIC_HEAD  (83716343L)
  105. #define MAGIC_TAIL  (11172363L)
  106.  
  107. /* Set MEMTRACE to TRUE to trace all memory operations. */
  108. #define MEMTRACE FALSE
  109.  
  110. /******************************************************************************/
  111.  
  112. /* The following structures define a type for the linked lists that keep      */
  113. /* track of the allocated blocks.                                             */
  114. typedef struct mm_t_
  115.   {
  116.    ulong         mm_mhead; /* Magic number protecting beginning of record.    */
  117.    ubyte_       *mm_pblok; /* Pointer to the allocated block.                 */
  118.    ubyte_       *mm_pfree; /* Pointer to next free byte in block (ALIGNED).   */
  119.    ulong         mm_nfree; /* Number of unused bytes available in the block.  */
  120.    struct mm_t_ *mm_pnext; /* Pointer to the header for the next block.       */
  121.    ulong         mm_mtail; /* Magic number protecting end of record.          */
  122.   } mm_t;
  123.  
  124. typedef mm_t *p_mm_t;      /* Handy to have a pointer type too.               */
  125.  
  126. /* The following two local variables point to the head of the temporary and   */
  127. /* permanent block lists. The first block in each list is that list's buffer. */
  128. LOCVAR p_mm_t p_perm = NULL;
  129. LOCVAR p_mm_t p_temp = NULL;
  130.  
  131. /******************************************************************************/
  132.  
  133. LOCAL void mm_check P_((p_mm_t));
  134. LOCAL void mm_check(p_mm)
  135. /* Checks the magic numbers in the specified block header object. */
  136. p_mm_t p_mm;
  137. {
  138.  as_cold(p_mm!=NULL,"mm_check: Null pointer.");
  139.  as_cold(p_mm->mm_mhead==MAGIC_HEAD,"mm_check: Corrupted header.");
  140.  as_cold(p_mm->mm_mtail==MAGIC_TAIL,"mm_check: Corrupted trailer.");
  141. }
  142.  
  143. /******************************************************************************/
  144.  
  145. LOCAL void mm_align P_((p_mm_t));
  146. LOCAL void mm_align(p_mm)
  147. /* Some machines are very fussy about the memory alignment of allocated       */
  148. /* objects. To solve this problem, the mm_pfree pointer is always kept at an  */
  149. /* "aligned" address. This function accepts a pointer to the header of a      */
  150. /* block whose mm_pfree pointer is possibly unaligned and consumes bytes      */
  151. /* until mm_pfree is aligned.                                                 */
  152. p_mm_t p_mm;
  153. {
  154.  ubyte bump;
  155.  ubyte consume;
  156.  
  157.  mm_check(p_mm);
  158.  
  159.  /* Work out how many bytes are sticking out over the alignment boundary. */
  160.  bump = ((ulong) p_mm->mm_pfree) & ALIGN_MASK;
  161.  
  162.  /* Return i